package alp.starcode.sanping.information.service;

import alp.starcode.common.base.exception.OperateException;
import alp.starcode.common.base.exception.ParamsNullException;
import alp.starcode.common.mybatis.page.Pagination;
import alp.starcode.common.mybatis.sort.Sorter;
import alp.starcode.common.mybatis.util.PageBeanUtil;
import alp.starcode.sanping.framework.base.BaseService;
import alp.starcode.sanping.framework.database.mariadb.mybatis.dao.InformationDao;
import alp.starcode.sanping.framework.database.mariadb.mybatis.entity.Information;
import alp.starcode.sanping.information.model.dto.InformationDTO;
import alp.starcode.sanping.information.model.vo.InformationVO;
import cn.hutool.core.bean.BeanUtil;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.UUID;

/**
 * TODO
 *
 * @author wujie
 * @date 2024/3/14 17:32
 */
@Service
public class InformationService extends BaseService {

    @Autowired
    InformationDao informationDao;

    /**
     * 分页查询信息
     *
     * @param pagination    分页对象
     * @param infoType 通知类型
     * @param region 地区
     * @param industryType 行业类型
     * @param sorters 排序字段
     * @return 分页对象
     */
    public Pagination<InformationVO> pageList(Pagination<Information> pagination, String infoType, String region, String industryType, Sorter sorters) {
        MPJLambdaWrapper<Information> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Information.class);
        // 通知类型
        if(StringUtils.isNotEmpty(infoType)) {
            queryWrapper.eq(Information::getInfoType, infoType);
        }
        // 地区
        if(StringUtils.isNotEmpty(region)) {
            queryWrapper.eq(Information::getRegion, region);
        }
        // 行业类型
        if(StringUtils.isNotEmpty(infoType)) {
            queryWrapper.eq(Information::getIndustryType, industryType);
        }
        // 有效数据
        queryWrapper.eq(Information::getIsDeleted, Boolean.FALSE);
        //构建排序条件
        sorters.sort(queryWrapper);
        //分页查询数据，并构建返回对象
        return PageBeanUtil.copyProperties(informationDao.page(pagination, queryWrapper), InformationVO.class);
    }

    /**
     * 根据Id获取信息
     *
     * @param id 主键Id
     * @return Role
     */
    public InformationVO getById(String id) {
        if (id == null || id.isEmpty()) {
            throw new ParamsNullException("[id]不能为空！");
        }
        MPJLambdaWrapper<Information> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Information.class);
        queryWrapper.eq(Information::getId, id);
        // 有效数据
        queryWrapper.eq(Information::getIsDeleted, Boolean.FALSE);

        Information entity = informationDao.getOne(queryWrapper);
        return BeanUtil.copyProperties(entity, InformationVO.class);
    }

    /**
     * 添加数据
     *
     * @param entityDTO 参数对象
     */
    public void add(InformationDTO entityDTO) {
        // 进行数据转换
        Information entity = entityDTO.converter();
        // 生成流水号
        String uuid = UUID.randomUUID().toString();
        entity.setId(uuid);
        entity.setIsDeleted(Boolean.FALSE);
        // 判断数据是否新增成功，失败抛出异常提示。
        if (!informationDao.save(entity)) {
            throw new OperateException("数据添加失败，写入数据异常：[%s]", entity);
        }
    }

    /**
     * 批量添加数据
     *
     * @param list 参数对象
     */
    public void addBatch(List<Information> list) {
//        informationDao.saveBatch(list);
        list.forEach((obj) -> {
            try {
                informationDao.save(obj);
            } catch (Exception ex) {
            }
        });
    }

    /**
     * 删除数据
     *
     * @param entityDTO 参数对象
     */
    public void delete(InformationDTO entityDTO) {
        Information entity = new Information();
        entity.setId(entityDTO.getId());
        entity.setIsDeleted(Boolean.TRUE);
        if (!informationDao.updateById(entity)) {
            throw new OperateException("数据删除失败，写入数据异常：[%s]", entity);
        }
    }

    /**
     * 修改数据
     *
     * @param entityDTO 参数对象
     */
    public void update(InformationDTO entityDTO) {
        Information entity = entityDTO.converter();
        //角色KEY不允许修改，避免产生脏数据
        if (!informationDao.updateById(entity)) {
            throw new OperateException("数据修改失败，写入数据异常：[%s]", entity);
        }
    }

    /**
     * 获取行业类型
     *
     */
    public List<Information> getIndustryType() {
        MPJLambdaWrapper<Information> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Information.class);
        // 有效数据
        queryWrapper.eq(Information::getIsDeleted, Boolean.FALSE);
        queryWrapper.groupBy(Information::getIndustryType);
        return informationDao.list(queryWrapper);
    }
}
